{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Pandas 基础统计方法\n",
        "\n",
        "本教程详细介绍 Pandas 中的基础统计方法：sum, count, min, max, mean, median, std, var 等。\n",
        "\n",
        "## 目录\n",
        "1. 计数统计 - count()\n",
        "2. 求和统计 - sum()\n",
        "3. 最值统计 - min(), max()\n",
        "4. 平均值统计 - mean()\n",
        "5. 中位数统计 - median()\n",
        "6. 标准差和方差 - std(), var()\n",
        "7. 其他统计方法\n",
        "8. 综合应用\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 导入库\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 1. 计数统计 - count()\n",
        "\n",
        "### 方法说明\n",
        "\n",
        "`count()` 方法统计非空值（非NaN）的数量。\n",
        "\n",
        "**语法:**\n",
        "```python\n",
        "df.count(axis=0, level=None, numeric_only=False)\n",
        "```\n",
        "\n",
        "**主要参数:**\n",
        "- `axis`: 0(按列统计) 或 1(按行统计)，默认 0\n",
        "- `numeric_only`: 是否只统计数值型列，默认 False\n",
        "\n",
        "**特点:**\n",
        "- ✅ 自动忽略 NaN 值\n",
        "- ✅ 适用于所有数据类型\n",
        "- ✅ 可以按列或按行统计\n",
        "\n",
        "**适用场景:** 检查数据完整性，统计有效数据量\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 示例1: 创建示例数据\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "np.random.seed(42)\n",
        "df = pd.DataFrame({\n",
        "    '姓名': ['张三', '李四', '王五', '赵六', '孙七', '周八'],\n",
        "    '年龄': [25, 30, np.nan, 28, 32, 27],\n",
        "    '工资': [8000, np.nan, 15000, np.nan, 9000, 12000],\n",
        "    '奖金': [1000, 2000, np.nan, 1500, np.nan, 1800],\n",
        "    '部门': ['技术', '销售', '技术', '人事', '技术', '销售']\n",
        "})\n",
        "\n",
        "print(\"原始数据:\")\n",
        "print(df)\n",
        "print(\"\\n数据类型:\")\n",
        "print(df.dtypes)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 示例2: 按列统计非空值数量\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "print(\"按列统计非空值数量:\")\n",
        "print(df.count())\n",
        "print(\"\\n只统计数值型列:\")\n",
        "print(df.count(numeric_only=True))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 示例3: 按行统计非空值数量\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "print(\"按行统计非空值数量:\")\n",
        "print(df.count(axis=1))\n",
        "print(\"\\n添加为列:\")\n",
        "df['非空值数量'] = df.count(axis=1)\n",
        "print(df)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 2. 求和统计 - sum()\n",
        "\n",
        "### 方法说明\n",
        "\n",
        "`sum()` 方法计算数值的和。\n",
        "\n",
        "**语法:**\n",
        "```python\n",
        "df.sum(axis=0, skipna=True, numeric_only=None, min_count=0)\n",
        "```\n",
        "\n",
        "**主要参数:**\n",
        "- `axis`: 0(按列求和) 或 1(按行求和)，默认 0\n",
        "- `skipna`: 是否跳过NaN值，默认 True\n",
        "- `numeric_only`: 是否只计算数值型列，默认 None\n",
        "- `min_count`: 非NaN值的最小数量，少于该数量返回NaN\n",
        "\n",
        "**特点:**\n",
        "- ✅ 默认跳过 NaN 值\n",
        "- ✅ 可以设置最小非空值数量要求\n",
        "- ✅ 适用于数值型数据\n",
        "\n",
        "**适用场景:** 计算总和、总计等\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 示例4: 按列求和\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "print(\"按列求和 (默认跳过NaN):\")\n",
        "print(df[['年龄', '工资', '奖金']].sum())\n",
        "print(\"\\n包括NaN的求和 (skipna=False):\")\n",
        "print(df[['年龄', '工资', '奖金']].sum(skipna=False))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 示例5: 按行求和\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# 计算每个人的总收入（工资+奖金）\n",
        "df['总收入'] = df[['工资', '奖金']].sum(axis=1)\n",
        "print(\"添加总收入列:\")\n",
        "print(df[['姓名', '工资', '奖金', '总收入']])\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 3. 最值统计 - min(), max()\n",
        "\n",
        "### 方法说明\n",
        "\n",
        "`min()` 和 `max()` 方法分别计算最小值和最大值。\n",
        "\n",
        "**语法:**\n",
        "```python\n",
        "df.min(axis=0, skipna=True, numeric_only=None)\n",
        "df.max(axis=0, skipna=True, numeric_only=None)\n",
        "```\n",
        "\n",
        "**主要参数:**\n",
        "- `axis`: 0(按列) 或 1(按行)，默认 0\n",
        "- `skipna`: 是否跳过NaN值，默认 True\n",
        "- `numeric_only`: 是否只计算数值型列，默认 None\n",
        "\n",
        "**特点:**\n",
        "- ✅ 自动跳过 NaN 值\n",
        "- ✅ 适用于数值型和字符串型数据\n",
        "- ✅ 可以按列或按行统计\n",
        "\n",
        "**适用场景:** 查找极值、数据范围分析\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 示例6: 按列查找最值\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "print(\"最小值:\")\n",
        "print(df[['年龄', '工资', '奖金']].min())\n",
        "print(\"\\n最大值:\")\n",
        "print(df[['年龄', '工资', '奖金']].max())\n",
        "print(\"\\n最小值索引位置:\")\n",
        "print(df[['年龄', '工资', '奖金']].idxmin())\n",
        "print(\"\\n最大值索引位置:\")\n",
        "print(df[['年龄', '工资', '奖金']].idxmax())\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 4. 平均值统计 - mean()\n",
        "\n",
        "### 方法说明\n",
        "\n",
        "`mean()` 方法计算算术平均值。\n",
        "\n",
        "**语法:**\n",
        "```python\n",
        "df.mean(axis=0, skipna=True, numeric_only=None)\n",
        "```\n",
        "\n",
        "**主要参数:**\n",
        "- `axis`: 0(按列) 或 1(按行)，默认 0\n",
        "- `skipna`: 是否跳过NaN值，默认 True\n",
        "- `numeric_only`: 是否只计算数值型列，默认 None\n",
        "\n",
        "**特点:**\n",
        "- ✅ 自动跳过 NaN 值\n",
        "- ✅ 只适用于数值型数据\n",
        "- ✅ 受异常值影响较大\n",
        "\n",
        "**适用场景:** 计算平均值、了解数据集中趋势\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "print(\"按列计算平均值:\")\n",
        "print(df[['年龄', '工资', '奖金']].mean())\n",
        "print(\"\\n平均年龄:\", df['年龄'].mean())\n",
        "print(\"平均工资:\", df['工资'].mean())\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 5. 中位数统计 - median()\n",
        "\n",
        "### 方法说明\n",
        "\n",
        "`median()` 方法计算中位数（50%分位数）。\n",
        "\n",
        "**语法:**\n",
        "```python\n",
        "df.median(axis=0, skipna=True, numeric_only=None)\n",
        "```\n",
        "\n",
        "**主要参数:**\n",
        "- `axis`: 0(按列) 或 1(按行)，默认 0\n",
        "- `skipna`: 是否跳过NaN值，默认 True\n",
        "- `numeric_only`: 是否只计算数值型列，默认 None\n",
        "\n",
        "**特点:**\n",
        "- ✅ 不受异常值影响\n",
        "- ✅ 比平均值更稳健\n",
        "- ✅ 适用于数值型数据\n",
        "\n",
        "**适用场景:** 计算中位数、稳健的集中趋势度量\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "print(\"按列计算中位数:\")\n",
        "print(df[['年龄', '工资', '奖金']].median())\n",
        "print(\"\\n中位数和平均值对比:\")\n",
        "comparison = pd.DataFrame({\n",
        "    '平均值': df[['年龄', '工资', '奖金']].mean(),\n",
        "    '中位数': df[['年龄', '工资', '奖金']].median()\n",
        "})\n",
        "print(comparison)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 6. 标准差和方差 - std(), var()\n",
        "\n",
        "### 方法说明\n",
        "\n",
        "`std()` 计算标准差，`var()` 计算方差。标准差是方差的平方根。\n",
        "\n",
        "**语法:**\n",
        "```python\n",
        "df.std(axis=0, skipna=True, ddof=1, numeric_only=None)\n",
        "df.var(axis=0, skipna=True, ddof=1, numeric_only=None)\n",
        "```\n",
        "\n",
        "**主要参数:**\n",
        "- `axis`: 0(按列) 或 1(按行)，默认 0\n",
        "- `skipna`: 是否跳过NaN值，默认 True\n",
        "- `ddof`: 自由度修正，默认 1（样本标准差），0为总体标准差\n",
        "- `numeric_only`: 是否只计算数值型列，默认 None\n",
        "\n",
        "**特点:**\n",
        "- ✅ 标准差衡量数据离散程度\n",
        "- ✅ 方差是标准差的平方\n",
        "- ✅ ddof=1 为样本标准差（默认），ddof=0 为总体标准差\n",
        "\n",
        "**适用场景:** 分析数据离散程度、数据稳定性\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "print(\"标准差 (std):\")\n",
        "print(df[['年龄', '工资', '奖金']].std())\n",
        "print(\"\\n方差 (var):\")\n",
        "print(df[['年龄', '工资', '奖金']].var())\n",
        "print(\"\\n验证: 标准差^2 = 方差\")\n",
        "std_values = df[['年龄', '工资', '奖金']].std()\n",
        "var_values = df[['年龄', '工资', '奖金']].var()\n",
        "print(\"std^2:\", std_values ** 2)\n",
        "print(\"var:\", var_values)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 7. 其他统计方法\n",
        "\n",
        "### 示例7: 偏度和峰度\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# 偏度 (skewness) - 衡量数据分布的对称性\n",
        "# 峰度 (kurtosis) - 衡量数据分布的尖锐程度\n",
        "print(\"偏度 (skew):\")\n",
        "print(df[['年龄', '工资', '奖金']].skew())\n",
        "print(\"\\n峰度 (kurtosis):\")\n",
        "print(df[['年龄', '工资', '奖金']].kurtosis())\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 8. 综合应用\n",
        "\n",
        "### 示例8: 完整统计摘要\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# 创建完整的统计摘要\n",
        "numeric_cols = ['年龄', '工资', '奖金']\n",
        "stats_summary = pd.DataFrame({\n",
        "    'count': df[numeric_cols].count(),\n",
        "    'sum': df[numeric_cols].sum(),\n",
        "    'mean': df[numeric_cols].mean(),\n",
        "    'median': df[numeric_cols].median(),\n",
        "    'std': df[numeric_cols].std(),\n",
        "    'var': df[numeric_cols].var(),\n",
        "    'min': df[numeric_cols].min(),\n",
        "    'max': df[numeric_cols].max(),\n",
        "    'range': df[numeric_cols].max() - df[numeric_cols].min(),\n",
        "    'skew': df[numeric_cols].skew(),\n",
        "    'kurt': df[numeric_cols].kurtosis()\n",
        "})\n",
        "\n",
        "print(\"完整统计摘要:\")\n",
        "print(stats_summary.T)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### 示例9: 按条件统计\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# 按部门统计平均工资\n",
        "print(\"各部门统计:\")\n",
        "dept_stats = df.groupby('部门')['工资'].agg(['count', 'mean', 'median', 'std', 'min', 'max'])\n",
        "print(dept_stats)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 总结\n",
        "\n",
        "**基础统计方法总结:**\n",
        "1. ✅ **count()**: 统计非空值数量\n",
        "2. ✅ **sum()**: 计算总和\n",
        "3. ✅ **min(), max()**: 查找最小值和最大值\n",
        "4. ✅ **mean()**: 计算平均值\n",
        "5. ✅ **median()**: 计算中位数（稳健的平均值）\n",
        "6. ✅ **std()**: 计算标准差（衡量离散程度）\n",
        "7. ✅ **var()**: 计算方差（标准差的平方）\n",
        "8. ✅ **skew()**: 计算偏度（分布对称性）\n",
        "9. ✅ **kurtosis()**: 计算峰度（分布尖锐程度）\n",
        "\n",
        "**最佳实践:**\n",
        "- 使用 `count()` 检查数据完整性\n",
        "- 使用 `mean()` 和 `median()` 了解集中趋势\n",
        "- 使用 `std()` 和 `var()` 了解离散程度\n",
        "- 结合多种统计方法全面了解数据特征\n",
        "- 注意 NaN 值的处理（skipna参数）\n"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "ml311",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}
